home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 22 / Cream of the Crop 22.iso / program / ctlib100.zip / INSTALL.LZH / MTDTESTS.PAS < prev    next >
Pascal/Delphi Source File  |  1996-10-12  |  82KB  |  2,547 lines
  1. {**************************************************************************}
  2. {*  BitSoft Developmnet, L.L.C.                                           *}
  3. {*  Copyright (C) 1995, 1996 BitSoft Development, L.L.C.                  *}
  4. {*  All rights reserved.                                                  *}
  5. {**************************************************************************}
  6.  
  7. unit MtdTests;
  8.  
  9. {$X+,B-}
  10.  
  11. interface
  12.  
  13. uses BsdTypes,
  14.      Containr, ctArrays, ctQueues, ctTrees, ctStacks, ctBiTree;
  15.  
  16. { TContainer methods }
  17.  
  18. procedure TestContainerInsert (Container: PContainer; TotalItems : LongInt);
  19. { Inserts TotalItems items into the container.  This method is used for
  20.   inserting in the container the data that will be used in other tests. }
  21.  
  22. procedure TestStaticSequenceInsert (Sequence: PSequence; TotalItems :
  23.   LongInt);
  24. { Inserts TotalItems items into the container, but using AtPut instead of
  25.   the standard Insert method.  This test is useful when working with
  26.   non-dynamically sized data structures, like for example, arrays. }
  27.  
  28. procedure TestContainerForEach (Container: PContainer);
  29. { Tests the ForEach method. }
  30.  
  31. procedure TestContainerForEachThat (Container: PContainer);
  32. { Tests the ForEachThat method. }
  33.  
  34. procedure TestSequenceDelete (Sequence: PSequence);
  35. { Tests the Delete method in TSequence descendants.  Separate methods for
  36.   sequences and graphs are needed because of the way items to be deleted
  37.   are selected.  The Delete method is common to all containers. }
  38.  
  39. procedure TestGraphDelete (Graph: PGraph);
  40. { Tests the Delete method in TGraph descendants.  Separate methods for
  41.   sequences and graphs are needed because of the way items to be deleted
  42.   are selected.  The Delete method is common to all containers. }
  43.  
  44. procedure TestSequenceDeleteAll (Sequence : PSequence);
  45. { Tests the DeleteAll method in sequences.  Separate methods for sequences
  46.   and graphs are needed because of the way the list of deleted items is
  47.   built.  The DeleteAll method is common to all containers.
  48.  
  49.   Note:  There must be only TotalDeleteItems items (see utils.pas) in the
  50.   container.  Otherwise, there will be a memory leak when the items are
  51.   deleted from the container.}
  52.  
  53. procedure TestGraphDeleteAll (Graph : PGraph);
  54. { Tests the DeleteAll method in graphs. Separate methods for sequences
  55.   and graphs are needed because of the way the list of deleted items is
  56.   built.  The DeleteAll method is common to all containers.
  57.  
  58.   Note:  There must be only TotalDeleteItems items (see utils.pas) in the
  59.   container.  Otherwise, there will be a memory leak when the items are
  60.   deleted from the container.}
  61.  
  62. procedure TestContainerDeleteAllThat (Container: PContainer);
  63. { Tests the DeleteAllThat method. }
  64.  
  65. procedure TestSequenceFree (Sequence: PSequence);
  66. { Tests the Free method in TSequence descendants.  Separate methods for
  67.   sequences and graphs are needed because of the way items to be freed
  68.   are selected.  The Free method is common to all containers. }
  69.  
  70. procedure TestGraphFree (Graph: PGraph);
  71. { Tests the Free method in TGraph descendants.  Separate methods for
  72.   sequences and graphs are needed because of the way items to be freed
  73.   are selected.  The Free method is common to all containers. }
  74.  
  75. procedure TestContainerFreeAll (Container : PContainer);
  76.  
  77. procedure TestContainerFreeAllThat (Container: PContainer);
  78. { Tests the FreeAllThat method. }
  79.  
  80. procedure TestContainerPack (Container : PContainer);
  81.  
  82. { TSequence methods }
  83.  
  84. procedure TestSequenceAt (Sequence : PSequence);
  85. procedure TestSequenceAtDelete (Sequence : PSequence);
  86. procedure TestSequenceAtFree (Sequence : PSequence);
  87. procedure TestSequenceAtInsert (Sequence : PSequence);
  88.  
  89. procedure TestStaticSequenceAtInsert (Sequence : PSequence);
  90. { Tests the AtInsert method in static (i.e. not dynamically sized) sequences.
  91.   In static sequences, the last item in the sequence gets deleted but not
  92.   disposed of.  This test takes this into account and frees the last
  93.   item in the sequence before inserting a new one. }
  94.  
  95. procedure TestSequenceAtPut (Sequence : PSequence);
  96. procedure TestSequenceFirst (Sequence : PSequence);
  97. procedure TestSequenceNext (Sequence : PSequence);
  98. procedure TestSequenceLast (Sequence : PSequence);
  99. procedure TestSequencePrev (Sequence : PSequence);
  100. procedure TestSequenceFirstThat (Sequence : PSequence);
  101. procedure TestSequenceNextThat (Sequence : PSequence);
  102. procedure TestSequenceLastThat (Sequence : PSequence);
  103. procedure TestSequencePrevThat (Sequence : PSequence);
  104. procedure TestSequenceSearch (Sequence : PSequence);
  105.  
  106. { TGraph methods }
  107.  
  108. procedure TestGraphFirst (Graph : PGraph);
  109. procedure TestGraphLast (Graph : PGraph);
  110. procedure TestGraphNext (Graph : PGraph);
  111. procedure TestGraphPrev (Graph : PGraph);
  112. procedure TestGraphFirstThat (Graph : PGraph; var Key: String5);
  113. procedure TestGraphLastThat (Graph : PGraph; var Key: String5);
  114. procedure TestGraphNextThat (Graph : PGraph; var Key: String5);
  115. procedure TestGraphPrevThat (Graph : PGraph; var Key: String5);
  116. procedure TestGraphDuplicates (Graph : PGraph; var DuplicateKey: String5);
  117. procedure TestGraphKeyFirst (Graph : PGraph; Key : String5);
  118. procedure TestGraphNextExactMatch(Graph : PGraph; DuplicateKey: String5);
  119. procedure TestGraphPrevExactMatch(Graph : PGraph; DuplicateKey: String5);
  120. procedure TestGraphKeyLast (Graph : PGraph; Key : String5);
  121. procedure TestGraphKeyFirstThat(Graph : PGraph; DuplicateKey : String5);
  122. procedure TestGraphKeyLastThat(Graph : PGraph; DuplicateKey : String5);
  123. procedure TestGraphItemPut (Graph : PGraph; Key : String5);
  124. procedure TestGraphItemReplace (Graph : PGraph; Key : String5);
  125. procedure TestGraphFind (Graph : PGraph; Key : String5);
  126. procedure TestGraphFindThat (Graph : PGraph; Key : String5);
  127.  
  128. { Array-specific methods }
  129.  
  130. procedure TestArrayAtClear (TestArray : PDynamicArray);
  131.  
  132. { Queue-specific methods }
  133.  
  134. procedure TestQueueEnqueue (Queue : PQueue);
  135. procedure TestQueueRemove (Queue : PQueue);
  136. procedure TestQueueFront (Queue : PQueue);
  137. procedure TestQueueRear (Queue : PQueue);
  138. procedure TestDoubleEndedQueueRemoveFirst (Queue : PDoubleEndedQueue);
  139. procedure TestDoubleEndedQueueRemoveLast (Queue : PDoubleEndedQueue);
  140.  
  141. { Stack-specific methods }
  142.  
  143. procedure TestHugeCollectionStackPush (Stack : PHugeCollectionStack);
  144. procedure TestHugeCollectionStackPop (Stack : PHugeCollectionStack);
  145. procedure TestHugeCollectionStackTop (Stack : PHugeCollectionStack);
  146. procedure TestHugeCollectionStackBottom (Stack : PHugeCollectionStack);
  147.  
  148. procedure TestArrayStackPush (Stack : PArrayStack);
  149. procedure TestArrayStackPop (Stack : PArrayStack);
  150. procedure TestArrayStackTop (Stack : PArrayStack);
  151. procedure TestArrayStackBottom (Stack : PArrayStack);
  152.  
  153. procedure TestHugeArrayStackPush (Stack : PHugeArrayStack);
  154. procedure TestHugeArrayStackPop (Stack : PHugeArrayStack);
  155. procedure TestHugeArrayStackTop (Stack : PHugeArrayStack);
  156. procedure TestHugeArrayStackBottom (Stack : PHugeArrayStack);
  157.  
  158. procedure TestLinkedStackPush (Stack : PLinkedStack);
  159. procedure TestLinkedStackPop (Stack : PLinkedStack);
  160. procedure TestLinkedStackTop (Stack : PLinkedStack);
  161. procedure TestLinkedStackBottom (Stack : PLinkedStack);
  162.  
  163. procedure TestStreamStackPush (Stack : PStreamStack);
  164. procedure TestStreamStackPop (Stack : PStreamStack);
  165. procedure TestStreamStackTop (Stack : PStreamStack);
  166. procedure TestStreamStackBottom (Stack : PStreamStack);
  167.  
  168. { Binary Tree-specific methods }
  169.  
  170. procedure TestTreeTraverse(Tree: PBinaryTree);
  171. procedure TestTreeTraverseThat(Tree: PBinaryTree);
  172.  
  173. implementation
  174.  
  175. uses Objects, Drivers, Memory,
  176.      BsdTest,
  177.      ctCollec,
  178.      ObjTests, Utils, Types, Data;
  179.  
  180. {****************************************************************************}
  181. { TestArrayAtClear                                                           }
  182. {****************************************************************************}
  183. procedure TestArrayAtClear (TestArray : PDynamicArray);
  184. var
  185.   Item : Pointer;
  186.   i : Integer;
  187.   Index : LongInt;
  188.   StrIndex : string;
  189. begin
  190.   if ExitTesting
  191.     then Exit;
  192.   StartTest('AtClear', 'Clearing items at random...');
  193.   Writeln(TestWindow^.T);
  194.   Randomize;
  195.   for i := 1 to 20 do
  196.   begin
  197.     Item := nil;
  198.     repeat
  199.       TestArray^.DoneItem(Item);
  200.       Index := Random(Pred(TestArray^.Count));
  201.       Item := TestArray^.At(Index);
  202.     until (Item <> nil)  and (TestReader^.ExtractText(Item) <> nil);
  203.     Str(Index, StrIndex);
  204.     WriteSubHeader('Clearing '+TestReader^.ExtractText(Item)^+' at index '+
  205.       StrIndex);
  206.     TestArray^.DoneItem(Item);
  207.     SetInitTime;
  208.     TestArray^.AtClear(Index);
  209.     SetFinalTime;
  210.     WriteTime;
  211.   end; { for }
  212.   NotifyDataChange;
  213.   PauseTest;
  214. end;
  215.  
  216. {****************************************************************************}
  217. { TestArrayStackBottom                                                       }
  218. {****************************************************************************}
  219. procedure TestArrayStackBottom (Stack : PArrayStack);
  220. var
  221.   Item : Pointer;
  222. begin
  223.   if ExitTesting
  224.     then Exit;
  225.   StartTest('Bottom', 'Getting item at the bottom of the stack...');
  226.   Item := Stack^.Bottom;
  227.   StopTest;
  228.   TestReader^.ShowItem(Item);
  229.   PauseTest;
  230. end;
  231.  
  232. {****************************************************************************}
  233. { TestArrayStackPop                                                          }
  234. {****************************************************************************}
  235. procedure TestArrayStackPop (Stack : PArrayStack);
  236. var
  237.   Item : Pointer;
  238.   i : Integer;
  239. begin
  240.   if ExitTesting
  241.     then Exit;
  242.   StartTest('Pop', 'Getting all items out of the stack...');
  243.   Writeln(TestWindow^.T);
  244.   for i := 1 to Stack^.Count do
  245.   begin
  246.     SetInitTime;
  247.     Item := Stack^.Pop;
  248.     SetFinalTime;
  249.     WriteSubHeader('Popping '+TestReader^.ExtractText(Item)^);
  250.     WriteTime;
  251.     Stack^.FreeItem(Item);
  252.   end; { for }
  253.   PauseTest;
  254. end;
  255.  
  256. {****************************************************************************}
  257. { TestArrayStackPush                                                         }
  258. {****************************************************************************}
  259. procedure TestArrayStackPush (Stack : PArrayStack);
  260. var
  261.   i : Integer;
  262.   Item : Pointer;
  263.   Key : String5;
  264.   F : Text;
  265. begin
  266.   if ExitTesting
  267.     then Exit;
  268.   StartTest('Push', 'Adding 20 items to the stack...');
  269.   Writeln(TestWindow^.T);
  270.   Assign(F, 'Items.Dat');
  271.   Reset(F);
  272.   for i := 1 to 20 do
  273.   begin
  274.     Readln(F, Key);
  275.     if LowMemory
  276.       then begin
  277.              Writeln(TestWindow^.T);
  278.              Writeln(TestWindow^.T);
  279.              Writeln(TestWindow^.T, 'Not enough memory... aborting test.');
  280.              ExitTesting := True;
  281.              Close(F);
  282.              ResetApplication;
  283.              Exit;
  284.            end { if }
  285.       else begin
  286.              CreateNonDynamicTestRec(Key+' ', 0, NonDynamicRec);
  287.              Item := @NonDynamicRec;
  288.            end; { else }
  289.     SetInitTime;
  290.     Stack^.Push(Item);
  291.     SetFinalTime;
  292.     WriteSubHeader('Pushing '+Key);
  293.     WriteTime;
  294.   end; { for }
  295.   PauseTest;
  296. end;
  297.  
  298. {****************************************************************************}
  299. { TestArrayStackTop                                                          }
  300. {****************************************************************************}
  301. procedure TestArrayStackTop (Stack : PArrayStack);
  302. var
  303.   Item : Pointer;
  304. begin
  305.   if ExitTesting
  306.     then Exit;
  307.   StartTest('Top', 'Getting item at the top of the stack...');
  308.   Item := Stack^.Top;
  309.   StopTest;
  310.   TestReader^.ShowItem(Item);
  311.   PauseTest;
  312. end;
  313.  
  314. {****************************************************************************}
  315. { TestContainerDeleteAllThat                                                 }
  316. {****************************************************************************}
  317. procedure TestContainerDeleteAllThat (Container : PContainer);
  318. var
  319.   Item : Pointer;
  320.   DeletedItems : PStreamCollection;
  321.   Counter : Integer;
  322.  
  323.   function Match(Item : Pointer) : Boolean; far;
  324.   begin
  325.     if (Item <> nil) and (TestReader^.ExtractText(Item) <> nil)
  326.       then if TestReader^.ExtractText(Item)^[3] = 'J'
  327.              then begin
  328.                     if TestingMemArray
  329.                       then Container^.FreeItem(Item)
  330.                       else DeletedItems^.Insert(Item);
  331.                     Inc(Counter);
  332.                     Match := True;
  333.                   end { if }
  334.              else Match := False
  335.       else Match := False;
  336.   end; { Match }
  337.  
  338.   procedure FreeItem (Item : Pointer); far;
  339.   begin
  340.     Container^.FreeItem(Item);
  341.   end;
  342.  
  343. begin
  344.   if ExitTesting
  345.     then Exit;
  346.   DeletedItems := New(PStreamCollection, Init(500, 500));
  347.   if DeletedItems = nil
  348.     then begin
  349.            Writeln(TestWindow^.T);
  350.            Writeln(TestWindow^.T);
  351.            Writeln(TestWindow^.T, 'Not enough memory... aborting test.');
  352.            ExitTesting := True;
  353.            ResetApplication;
  354.            Exit;
  355.          end; { if }
  356.   Counter := 0;
  357.   StartTest('DeleteAllThat', 'Deleting all items with 3rd character equal '+
  358.     'to ''J''...');
  359.   Container^.DeleteAllThat(@Match);
  360.   StopTest;
  361.   if not TestingMemArray
  362.     then begin
  363.            DeletedItems^.ForEach(@FreeItem);
  364.            DeletedItems^.DeleteAll;
  365.          end; { if }
  366.   Dispose(DeletedItems, Done);
  367.   WriteNumResult('Total items deleted:', Counter);
  368.   NotifyDataChange;
  369.   PauseTest;
  370. end;
  371.  
  372. {****************************************************************************}
  373. { TestContainerForEach                                                       }
  374. {****************************************************************************}
  375. procedure TestContainerForEach (Container: PContainer);
  376.  
  377.   procedure ChangeLastCharacter(Item : Pointer); far;
  378.   begin
  379.     if (Item <> nil) and (TestReader^.ExtractText(Item) <> nil)
  380.       then TestReader^.ExtractText(Item)^[5] := '-';
  381.   end; { ChangeLastCharacter }
  382.  
  383. begin
  384.   if ExitTesting
  385.     then Exit;
  386.   StartTest('ForEach', 'Appending a ''-'' character to all keys...');
  387.   Container^.ForEach(@ChangeLastCharacter);
  388.   StopTest;
  389.   PauseTest;
  390. end;
  391.  
  392. {****************************************************************************}
  393. { TestContainerForEachThat                                                   }
  394. {****************************************************************************}
  395. procedure TestContainerForEachThat (Container: PContainer);
  396.  
  397.   function Match(Item : Pointer): Boolean; far;
  398.   begin
  399.     if (Item <> nil) and (TestReader^.ExtractText(Item) <> nil)
  400.       then if TestReader^.ExtractText(Item)^[3] = 'R'
  401.              then Match := True
  402.              else Match := False
  403.       else Match := False;
  404.   end; { Match }
  405.  
  406.   procedure ChangeLastCharacter(Item : Pointer); far;
  407.   begin
  408.     if (Item <> nil) and (TestReader^.ExtractText(Item) <> nil)
  409.       then TestReader^.ExtractText(Item)^[5] := '@';
  410.   end; { ChangeLastCharacter }
  411.  
  412. begin
  413.   if ExitTesting
  414.     then Exit;
  415.   StartTest('ForEachThat',
  416.     'Changing the last character of all items with ''R'' as the 3rd '+
  417.     'character to @...');
  418.   Container^.ForEachThat(@Match, @ChangeLastCharacter);
  419.   StopTest;
  420.   PauseTest;
  421. end;
  422.  
  423. {****************************************************************************}
  424. { TestContainerFreeAll                                                       }
  425. {****************************************************************************}
  426. procedure TestContainerFreeAll (Container : PContainer);
  427. begin
  428.   if ExitTesting
  429.     then Exit;
  430.   StartTest('FreeAll', 'Disposing of all items in the container...');
  431.   Container^.FreeAll;
  432.   StopTest;
  433.   NotifyDataChange;
  434.   PauseTest;
  435. end;
  436.  
  437. {****************************************************************************}
  438. { TestContainerFreeAllThat                                                   }
  439. {****************************************************************************}
  440. procedure TestContainerFreeAllThat (Container : PContainer);
  441. var
  442.   Item : Pointer;
  443.   Counter : Integer;
  444.  
  445.   function Match(Item : Pointer) : Boolean; far;
  446.   begin
  447.     if (Item <> nil) and (TestReader^.ExtractText(Item) <> nil)
  448.       then if TestReader^.ExtractText(Item)^[3] = 'B'
  449.              then begin
  450.                     Inc(Counter);
  451.                     Match := True
  452.                   end { if }
  453.              else Match := False
  454.       else Match := False;
  455.   end; { Match }
  456.  
  457. begin
  458.   if ExitTesting
  459.     then Exit;
  460.   Counter := 0;
  461.   StartTest('FreeAllThat', 'Freeing all items with 3rd character equal '+
  462.     'to ''B''...');
  463.   Container^.FreeAllThat(@Match);
  464.   StopTest;
  465.   WriteNumResult('Total items freed:', Counter);
  466.   NotifyDataChange;
  467.   PauseTest;
  468. end;
  469.  
  470. {****************************************************************************}
  471. { TestContainerInsert                                                        }
  472. {****************************************************************************}
  473. procedure TestContainerInsert (Container: PContainer; TotalItems: LongInt);
  474. var
  475.   SubHeader : string;
  476.   F : Text;
  477.   i : LongInt;
  478.   Key : String5;
  479.   Item : Pointer;
  480. begin
  481.   if ExitTesting
  482.     then Exit;
  483.   Assign(F, 'items.dat');
  484.   Reset(F);
  485.   FormatStr(SubHeader, 'Inserting %d items into the container...',
  486.     TotalItems);
  487.   StartTest('Insert', SubHeader);
  488.   for i := 0 to Pred(TotalItems) do
  489.   begin
  490.     Readln(F, Key);
  491.     if LowMemory
  492.       then begin
  493.              Writeln(TestWindow^.T);
  494.              Writeln(TestWindow^.T);
  495.              Writeln(TestWindow^.T, 'Not enough memory... aborting test.');
  496.              ExitTesting := True;
  497.              Close(F);
  498.              ResetApplication;
  499.              Exit;
  500.            end { if }
  501.       else if UseNonDynamicTestRec
  502.              then begin
  503.                     CreateNonDynamicTestRec(Key+' ', 0, NonDynamicRec);
  504.                     Item := @NonDynamicRec;
  505.                   end { if }
  506.       else if UseNonDynamicTestObject
  507.              then begin
  508.                     CreateNonDynamicTestObject(Key+' ', 0, NonDynamicObject);
  509.                     Item := @NonDynamicObject;
  510.                   end { if }
  511.       else if UseNonDynamicTestStaticObject
  512.              then begin
  513.                     CreateNonDynamicTestStaticObject(Key+' ', 0,
  514.                       NonDynamicStaticObject);
  515.                     Item := @NonDynamicStaticObject;
  516.                   end { if }
  517.       else Item := CreateItem(Key+' ', 0);
  518.     Container^.Insert(Item);
  519.   end; { for }
  520.   StopTest;
  521.   Close(F);
  522.   NotifyDataChange;
  523.   PauseTest;
  524. end;
  525.  
  526. {****************************************************************************}
  527. { TestContainerPack                                                          }
  528. {****************************************************************************}
  529. procedure TestContainerPack (Container : PContainer);
  530. begin
  531.   if ExitTesting
  532.     then Exit;
  533.   StartTest('Pack', 'Packing the container...');
  534.   Container^.Pack;
  535.   StopTest;
  536.   NotifyDataChange;
  537.   PauseTest;
  538. end;
  539.  
  540. {****************************************************************************}
  541. { TestDoubleEndedQueueRemoveFirst                                            }
  542. {****************************************************************************}
  543. procedure TestDoubleEndedQueueRemoveFirst (Queue : PDoubleEndedQueue);
  544. var
  545.   Item : Pointer;
  546. begin
  547.   if ExitTesting
  548.     then Exit;
  549.   StartTest('RemoveFirst', 'Removing first item in the queue...');
  550.   Item := PDoubleEndedQueue(Queue)^.RemoveFirst;
  551.   StopTest;
  552.   TestReader^.ShowItem(Item);
  553.   Queue^.FreeItem(Item);
  554.   NotifyDataChange;
  555.   PauseTest;
  556. end;
  557.  
  558. {****************************************************************************}
  559. { TestDoubleEndedQueueRemoveLast                                             }
  560. {****************************************************************************}
  561. procedure TestDoubleEndedQueueRemoveLast (Queue : PDoubleEndedQueue);
  562. var
  563.   Item : Pointer;
  564. begin
  565.   if ExitTesting
  566.     then Exit;
  567.   StartTest('RemoveLast', 'Removing last item in the queue...');
  568.   Item := PDoubleEndedQueue(Queue)^.RemoveLast;
  569.   StopTest;
  570.   TestReader^.ShowItem(Item);
  571.   Queue^.FreeItem(Item);
  572.   NotifyDataChange;
  573.   PauseTest;
  574. end;
  575.  
  576. {****************************************************************************}
  577. { TestGraphDelete                                                            }
  578. {****************************************************************************}
  579. procedure TestGraphDelete (Graph : PGraph);
  580. var
  581.   Count : Byte;
  582.   Item, Hold : Pointer;
  583.  
  584.   function Match(Item : Pointer) : Boolean; far;
  585.   begin
  586.     if (Item <> nil) and (TestReader^.ExtractText(Item) <> nil)
  587.       then if TestReader^.ExtractText(Item)^[3] = 'X'
  588.              then Match := True
  589.              else Match := False
  590.       else Match := False;
  591.   end; { Match }
  592.  
  593. begin
  594.   if ExitTesting
  595.     then Exit;
  596.   WriteHeader('Delete');
  597.   WriteSubHeader('Deleting the first 20 items with ''X'' as the 3rd '+
  598.     'character...');
  599.   Writeln(TestWindow^.T);
  600.   Item := Graph^.FirstThat(@Match);
  601.   Count := 1;
  602.   while (Item <> nil) and (Count <= 20) do
  603.   begin
  604.     WriteSubHeader('Deleting '+TestReader^.ExtractText(Item)^);
  605.     SetInitTime;
  606.     Graph^.Delete(Item);
  607.     SetFinalTime;
  608.     WriteTime;
  609.     Graph^.FreeItem(Item);
  610.     Item := Graph^.FirstThat(@Match);
  611.     Inc(Count)
  612.   end; { while }
  613.   WriteNumResult('Total items deleted:', Pred(Count));
  614.   NotifyDataChange;
  615.   PauseTest;
  616. end;
  617.  
  618. {****************************************************************************}
  619. { TestGraphDeleteAll                                                         }
  620. {****************************************************************************}
  621. procedure TestGraphDeleteAll (Graph : PGraph);
  622. var
  623.   Items : array [1..TotalDeleteItems] of Pointer;
  624.   Item : Pointer;
  625.   i : Integer;
  626.   GraphCount : LongInt;
  627. begin
  628.   if ExitTesting
  629.     then Exit;
  630.   GraphCount := Graph^.Count;
  631.   Item := Graph^.First;
  632.   i := 1;
  633.   while Item <> nil do
  634.   begin
  635.     Items[i] := Item;
  636.     Inc(i);
  637.     Item := Graph^.Next(Item);
  638.   end; { while }
  639.   StartTest('DeleteAll', 'Deleting all items in the container...');
  640.   Graph^.DeleteAll;
  641.   StopTest;
  642.   WriteSubHeader('Disposing of deleted items...');
  643.   if (TypeOf(Graph^) <> TypeOf(TTestObjectBTree))
  644.       and (TypeOf(Graph^) <> TypeOf(TTestObjectBPlusTree))
  645.     then for i := 1 to GraphCount do
  646.            Graph^.FreeItem(Items[i]);
  647.   Writeln(TestWindow^.T, '  done.');
  648.   NotifyDataChange;
  649.   PauseTest;
  650. end;
  651.  
  652. {****************************************************************************}
  653. { TestGraphDuplicates                                                        }
  654. {****************************************************************************}
  655. procedure TestGraphDuplicates (Graph : PGraph; var DuplicateKey : String5);
  656. var
  657.   Hold, Item : Pointer;
  658.   Counter : LongInt;
  659.  
  660.   function Match(Item : Pointer) : Boolean; far;
  661.   begin
  662.     if (Item <> nil) and (TestReader^.ExtractText(Item) <> nil)
  663.       then if TestReader^.ExtractText(Item)^ > 'GRKT'
  664.              then Match := True
  665.              else Match := False
  666.       else Match := False;
  667.   end; { Match }
  668.  
  669.   function MatchDuplicate(Item : Pointer) : Boolean; far;
  670.   begin
  671.     if (Item <> nil) and (TestReader^.ExtractText(Item) <> nil)
  672.       then if TestReader^.ExtractText(Item)^ = DuplicateKey
  673.              then MatchDuplicate := True
  674.              else MatchDuplicate := False
  675.       else MatchDuplicate := False;
  676.   end; { MatchDuplicate }
  677.  
  678. begin
  679.   if ExitTesting
  680.     then Exit;
  681.   Item := Graph^.FirstThat(@Match);
  682.   DuplicateKey := TestReader^.ExtractText(Item)^;
  683.   StartTest('Duplicates:', 'Testing duplicates in tree using the key:');
  684.   writeln(TestWindow^.T, DuplicateKey:13);
  685.   WriteSubHeader('(Duplicates is set to FALSE)');
  686.   Writeln(TestWindow^.T);
  687.   WriteSubHeader('Inserting first duplicate key...');
  688.   Writeln(TestWindow^.T);
  689.   if UseNonDynamicTestRec
  690.     then begin
  691.            CreateNonDynamicTestRec(DuplicateKey, 1, NonDynamicRec);
  692.            Item := @NonDynamicRec;
  693.          end { if }
  694.     else Item := CreateItem(DuplicateKey, 1);
  695.   Graph^.Insert(Item);
  696.   Graph^.Reset;
  697.   WriteSubHeader('Setting Duplicates to TRUE and trying again...');
  698.   SetInitTime;
  699.   Graph^.Duplicates := True;
  700.   Graph^.Insert(Item);
  701.   for Counter := 2 to Pred(TotalDuplicates) do
  702.   begin
  703.     if UseNonDynamicTestRec
  704.       then begin
  705.              CreateNonDynamicTestRec(DuplicateKey, Counter, NonDynamicRec);
  706.              Item := @NonDynamicRec;
  707.            end { if }
  708.       else Item := CreateItem(DuplicateKey, Counter);
  709.     Graph^.Insert(Item);
  710.   end; { for }
  711.   StopTest;
  712.   NotifyDataChange;
  713.   PauseTest;
  714. end;
  715.  
  716. {****************************************************************************}
  717. { TestGraphFind                                                              }
  718. {****************************************************************************}
  719. procedure TestGraphFind (Graph : PGraph; Key : String5);
  720. var
  721.   Hits : LongInt;
  722. begin
  723.   if ExitTesting
  724.     then Exit;
  725.   StartTest('Find', 'Finding all items with a '+ Key + ' key...');
  726.   Graph^.Find(@Key, Hits);
  727.   StopTest;
  728.   WriteNumResult('Items found:', Hits);
  729.   PauseTest;
  730. end;
  731.  
  732. {****************************************************************************}
  733. { TestGraphFindThat                                                          }
  734. {****************************************************************************}
  735. procedure TestGraphFindThat (Graph : PGraph; Key : String5);
  736. var
  737.   Hits : LongInt;
  738.  
  739.   function Match(Item : Pointer) : Boolean; far;
  740.   begin
  741.     if (Item <> nil) and ((TestReader^.ExtractIndex(Item) mod 2) = 0) and
  742.        (TestReader^.ExtractIndex(Item) <> 0)
  743.       then Match := True
  744.       else Match := False;
  745.   end; { Match }
  746.  
  747. begin
  748.   if ExitTesting
  749.     then Exit;
  750.   StartTest('FindThat', 'Finding all '+ Key +
  751.     ' items with even Index field...');
  752.   Graph^.FindThat(@Key, @Match, Hits);
  753.   StopTest;
  754.   WriteNumResult('Items found...', Hits);
  755.   PauseTest;
  756. end;
  757.  
  758. {****************************************************************************}
  759. { TestGraphFree                                                              }
  760. {****************************************************************************}
  761. procedure TestGraphFree (Graph : PGraph);
  762. var
  763.   Count : Byte;
  764.   Item : Pointer;
  765.  
  766.   function Match(Item : Pointer) : Boolean; far;
  767.   begin
  768.     if (Item <> nil) and (TestReader^.ExtractText(Item)^[3] = 'W')
  769.       then Match := True
  770.       else Match := False;
  771.   end; { Match }
  772.  
  773. begin
  774.   if ExitTesting
  775.     then Exit;
  776.   WriteHeader('Free');
  777.   WriteSubHeader('Freeing the first 20 items with ''W'' as the 3rd '+
  778.     'character...');
  779.   Writeln(TestWindow^.T);
  780.   Item := Graph^.FirstThat(@Match);
  781.   Count := 1;
  782.   while (Item <> nil) and (Count <= 20) do
  783.   begin
  784.     WriteSubHeader('Freeing '+TestReader^.ExtractText(Item)^);
  785.     SetInitTime;
  786.     Graph^.Free(Item);
  787.     SetFinalTime;
  788.     WriteTime;
  789.     Item := Graph^.FirstThat(@Match);
  790.     Inc(Count);
  791.   end; { while }
  792.   WriteNumResult('Total items freed:', Pred(Count));
  793.   NotifyDataChange;
  794.   PauseTest;
  795. end;
  796.  
  797. {****************************************************************************}
  798. { TestGraphFirst                                                             }
  799. {****************************************************************************}
  800. procedure TestGraphFirst (Graph : PGraph);
  801. var
  802.   Item : Pointer;
  803. begin
  804.   if ExitTesting
  805.     then Exit;
  806.   StartTest('First', 'Retrieving the first item in the container...');
  807.   Item := Graph^.First;
  808.   StopTest;
  809.   TestReader^.ShowItem(Item);
  810.   Graph^.DoneItem(Item);
  811.   PauseTest;
  812. end;
  813.  
  814. {****************************************************************************}
  815. { TestGraphFirstThat                                                         }
  816. {****************************************************************************}
  817. procedure TestGraphFirstThat (Graph : PGraph; var Key: String5);
  818. var
  819.   Item : Pointer;
  820.  
  821.   function Match(Item : Pointer) : Boolean; far;
  822.   begin
  823.     if (Item <> nil) and (TestReader^.ExtractText(Item) <> nil)
  824.       then if TestReader^.ExtractText(Item)^ > 'UXVT'
  825.              then Match := True
  826.              else Match := False
  827.       else Match := False;
  828.   end; { Match }
  829.  
  830. begin
  831.   if ExitTesting
  832.     then Exit;
  833.   StartTest('FirstThat', 'Retrieving first item with key > ''UXVT''');
  834.   Item := Graph^.FirstThat(@Match);
  835.   StopTest;
  836.   if Item <> nil
  837.     then begin
  838.            TestReader^.ShowItem(Item);
  839.            Key := TestReader^.ExtractText(Item)^;
  840.          end { if }
  841.     else begin
  842.            WriteResult('Not found');
  843.            Item := Graph^.First;
  844.            Key := TestReader^.ExtractText(Item)^;
  845.            Graph^.DoneItem(Item);
  846.          end; { else }
  847.   Graph^.DoneItem(Item);
  848.   PauseTest;
  849. end;
  850.  
  851. {****************************************************************************}
  852. { TestGraphKeyFirstThat                                                      }
  853. {****************************************************************************}
  854. procedure TestGraphKeyFirstThat(Graph : PGraph; DuplicateKey : String5);
  855. var
  856.   Item : Pointer;
  857.  
  858.   function Match(Item : Pointer) : Boolean; far;
  859.   begin
  860.     Match := (Item <> nil) and (TestReader^.ExtractIndex(Item) < 5);
  861.   end; { Match }
  862.  
  863. begin
  864.   if ExitTesting
  865.     then Exit;
  866.   StartTest('KeyFirstThat', 'Retrieving the first duplicate key item with '+
  867.     'an index lower than 5');
  868.   Item := Graph^.KeyFirstThat(@Match, @DuplicateKey);
  869.   StopTest;
  870.   if Item <> nil
  871.     then TestReader^.ShowItem(Item)
  872.     else WriteResult('... not found ...');
  873.   Graph^.DoneItem(Item);
  874.   PauseTest;
  875. end;
  876.  
  877. {****************************************************************************}
  878. { TestGraphKeyLastThat                                                       }
  879. {****************************************************************************}
  880. procedure TestGraphKeyLastThat(Graph : PGraph; DuplicateKey : String5);
  881. var
  882.   Item : Pointer;
  883.  
  884.   function Match(Item : Pointer) : Boolean; far;
  885.   begin
  886.     Match := (Item <> nil) and (TestReader^.ExtractIndex(Item) > 5);
  887.   end; { Match }
  888.  
  889. begin
  890.   if ExitTesting
  891.     then Exit;
  892.   StartTest('KeyFirstThat', 'Retrieving the last duplicate key item with '+
  893.     'an index higher than 5');
  894.   Item := Graph^.KeyLastThat(@Match, @DuplicateKey);
  895.   StopTest;
  896.   if Item <> nil
  897.     then TestReader^.ShowItem(Item)
  898.     else WriteResult('... not found ...');
  899.   Graph^.DoneItem(Item);
  900.   PauseTest;
  901. end;
  902.  
  903. {****************************************************************************}
  904. { TestGraphKeyFirst                                                          }
  905. {****************************************************************************}
  906. procedure TestGraphKeyFirst (Graph : PGraph; Key : String5);
  907. var
  908.   Item : Pointer;
  909. begin
  910.   if ExitTesting
  911.     then Exit;
  912.   StartTest('KeyFirst', 'Retrieving the first duplicate '+ Key +
  913.     ' key...');
  914.   Item := Graph^.KeyFirst(@Key);
  915.   StopTest;
  916.   TestReader^.ShowItem(Item);
  917.   Graph^.DoneItem(Item);
  918.   PauseTest;
  919. end;
  920.  
  921. {****************************************************************************}
  922. { TestGraphKeyLast                                                           }
  923. {****************************************************************************}
  924. procedure TestGraphKeyLast (Graph : PGraph; Key : String5);
  925. var
  926.   Item : Pointer;
  927. begin
  928.   if ExitTesting
  929.     then Exit;
  930.   StartTest('KeyLast', 'Retrieving the last duplicate '+ Key +
  931.     ' key...');
  932.   Item := Graph^.KeyLast(@Key);
  933.   StopTest;
  934.   TestReader^.ShowItem(Item);
  935.   Graph^.DoneItem(Item);
  936.   PauseTest;
  937. end;
  938.  
  939. {****************************************************************************}
  940. { TestGraphNextExactMatch(Graph                                              }
  941. {****************************************************************************}
  942. procedure TestGraphNextExactMatch(Graph : PGraph; DuplicateKey: String5);
  943. var
  944.   Hold, Item : Pointer;
  945. begin
  946.   if ExitTesting
  947.     then Exit;
  948.   WriteHeader('Next (ExactMatch = True)');
  949.   WriteSubHeader('Displaying in order the duplicate items...');
  950.   Writeln(TestWindow^.T);
  951.   Writeln(TestWindow^.T);
  952.   writeln('1');
  953.   Graph^.ExactMatch := True;
  954.   Item := Graph^.KeyFirst(@DuplicateKey);
  955.   while Item <> nil do
  956.   begin
  957.     TestReader^.ShowItem(Item);
  958.     Hold := Item;
  959.     Item := Graph^.Next(Item);
  960.     Graph^.DoneItem(Hold);
  961.   end; { while }
  962.   PauseTest;
  963. end;
  964.  
  965. {****************************************************************************}
  966. { TestGraphKeyPrev                                                           }
  967. {****************************************************************************}
  968. procedure TestGraphPrevExactMatch(Graph : PGraph; DuplicateKey: String5);
  969. var
  970.   Hold, Item : Pointer;
  971. begin
  972.   if ExitTesting
  973.     then Exit;
  974.   WriteHeader('Prev (ExactMatch = True)');
  975.   WriteSubHeader('Displaying in reverse order the duplicate items...');
  976.   Writeln(TestWindow^.T);
  977.   Writeln(TestWindow^.T);
  978.   Graph^.ExactMatch := True;
  979.   Item := Graph^.KeyLast(@DuplicateKey);
  980.   while Item <> nil do
  981.   begin
  982.     TestReader^.ShowItem(Item);
  983.     Hold := Item;
  984.     Item := Graph^.Prev(Item);
  985.     Graph^.DoneItem(Hold);
  986.   end; { while }
  987.   PauseTest;
  988. end;
  989.  
  990. {****************************************************************************}
  991. { TestGraphItemPut                                                           }
  992. {****************************************************************************}
  993. procedure TestGraphItemPut (Graph : PGraph; Key : String5);
  994. var
  995.   OldItem, NewItem : Pointer;
  996. begin
  997.   if ExitTesting
  998.     then Exit;
  999.   if UseNonDynamicTestRec
  1000.     then begin
  1001.            CreateNonDynamicTestRec('****', 1, NonDynamicRec);
  1002.            NewItem := @NonDynamicRec;
  1003.          end { if }
  1004.     else NewItem := CreateItem('****', 1);
  1005.   OldItem := Graph^.KeyFirst(@Key);
  1006.   StartTest('ItemPut', 'Replacing the first item with key '+ Key +
  1007.     ' with a new item with **** as its key...');
  1008.   Graph^.ItemPut(OldItem, NewItem);
  1009.   StopTest;
  1010.   Graph^.FreeItem(OldItem);
  1011.   NotifyDataChange;
  1012.   PauseTest;
  1013. end;
  1014.  
  1015. {****************************************************************************}
  1016. { TestGraphItemReplace                                                       }
  1017. {****************************************************************************}
  1018. procedure TestGraphItemReplace (Graph : PGraph; Key : String5);
  1019. var
  1020.   OldItem, NewItem : Pointer;
  1021. begin
  1022.   if ExitTesting
  1023.     then Exit;
  1024.   if UseNonDynamicTestRec
  1025.     then begin
  1026.            CreateNonDynamicTestRec(Copy(Key, 1, 4) + '*', 1, NonDynamicRec);
  1027.            NewItem := @NonDynamicRec;
  1028.          end { if }
  1029.     else NewItem := CreateItem(Copy(Key, 1, 4) + '*', 1);
  1030.   OldItem := Graph^.KeyFirst(@Key);
  1031.   StartTest('ItemReplace', 'Replacing the first item with key '+ Key +
  1032.     ' with a new item with '+Copy(Key, 1, 4) + '* as its key...');
  1033.   Graph^.ItemReplace(OldItem, NewItem);
  1034.   StopTest;
  1035.   NotifyDataChange;
  1036.   PauseTest;
  1037. end;
  1038.  
  1039. {****************************************************************************}
  1040. { TestGraphLast                                                              }
  1041. {****************************************************************************}
  1042. procedure TestGraphLast (Graph : PGraph);
  1043. var
  1044.   Item : Pointer;
  1045. begin
  1046.   if ExitTesting
  1047.     then Exit;
  1048.   StartTest('Last', 'Retrieving the last item in the container...');
  1049.   Item := Graph^.Last;
  1050.   StopTest;
  1051.   TestReader^.ShowItem(Item);
  1052.   Graph^.DoneItem(Item);
  1053.   PauseTest;
  1054. end;
  1055.  
  1056. {****************************************************************************}
  1057. { TestGraphLastThat                                                          }
  1058. {****************************************************************************}
  1059. procedure TestGraphLastThat (Graph : PGraph; var Key: String5);
  1060. var
  1061.   Item : Pointer;
  1062.  
  1063.   function Match(Item : Pointer) : Boolean; far;
  1064.   begin
  1065.     if (Item <> nil) and (TestReader^.ExtractText(Item)^ < 'DRTG')
  1066.       then Match := True
  1067.       else Match := False;
  1068.   end; { Match }
  1069.  
  1070. begin
  1071.   if ExitTesting
  1072.     then Exit;
  1073.   StartTest('LastThat', 'Retrieving last item with key < ''DRTG''');
  1074.   Item := Graph^.LastThat(@Match);
  1075.   StopTest;
  1076.   if Item <> nil
  1077.     then begin
  1078.            TestReader^.ShowItem(Item);
  1079.            Key := TestReader^.ExtractText(Item)^;
  1080.          end { if }
  1081.     else begin
  1082.            WriteResult('Not found');
  1083.            Item := Graph^.First;
  1084.            Key := TestReader^.ExtractText(Item)^;
  1085.            Graph^.DoneItem(Item);
  1086.          end; { else }
  1087.   Graph^.DoneItem(Item);
  1088.   PauseTest;
  1089. end;
  1090.  
  1091. {****************************************************************************}
  1092. { TestGraphNext                                                              }
  1093. {****************************************************************************}
  1094. procedure TestGraphNext (Graph : PGraph);
  1095. var
  1096.   Counter : LongInt;
  1097.   Item : Pointer;
  1098. begin
  1099.   if ExitTesting
  1100.     then Exit;
  1101.   StartTest('Next', 'Traversing the graph using First and Next...');
  1102.   Counter := 0;
  1103.   Graph^.ExactMatch := False;
  1104.   Item := Graph^.First;
  1105.   while Item <> nil do
  1106.   begin
  1107.     Graph^.DoneItem(Item);
  1108.     Inc(Counter);
  1109.     Item := Graph^.Next(Item);
  1110.   end; { while }
  1111.   StopTest;
  1112.   WriteNumResult('Total nodes visited:', Counter);
  1113.   PauseTest;
  1114. end;
  1115.  
  1116. {****************************************************************************}
  1117. { TestGraphNextThat                                                          }
  1118. {****************************************************************************}
  1119. procedure TestGraphNextThat (Graph : PGraph; var Key: String5);
  1120. var
  1121.   Hold, Item : Pointer;
  1122.  
  1123.   function MatchFirst(Item : Pointer) : Boolean; far;
  1124.   begin
  1125.     if (Item <> nil) and (TestReader^.ExtractText(Item)^ > 'UXVT')
  1126.       then MatchFirst := True
  1127.       else MatchFirst := False;
  1128.   end; { MatchFirst }
  1129.  
  1130.   function MatchNext(Item : Pointer) : Boolean; far;
  1131.   begin
  1132.     if (Item <> nil) and (TestReader^.ExtractText(Item)^[3] = 'Q')
  1133.      then MatchNext := True
  1134.      else MatchNext := False;
  1135.   end; { MatchNext }
  1136.  
  1137. begin
  1138.   if ExitTesting
  1139.     then Exit;
  1140.   Graph^.ExactMatch := False;
  1141.   Item := Graph^.FirstThat(@MatchFirst);
  1142.   StartTest('NextThat', 'Retrieving next item with ''Q'' as the 3rd '+
  1143.     'character after first item with key > ''UXVT''');
  1144.   Hold := Item;
  1145.   Item := Graph^.NextThat(@MatchNext, Item);
  1146.   StopTest;
  1147.   if Item <> nil
  1148.     then begin
  1149.            TestReader^.ShowItem(Item);
  1150.            Key := TestReader^.ExtractText(Item)^;
  1151.          end { if }
  1152.     else begin
  1153.            WriteResult('Not found');
  1154.            Item := Graph^.First;
  1155.            Key := TestReader^.ExtractText(Item)^;
  1156.            Graph^.DoneItem(Item);
  1157.          end; { else }
  1158.   Graph^.DoneItem(Hold);
  1159.   Graph^.DoneItem(Item);
  1160.   PauseTest;
  1161. end;
  1162.  
  1163.  
  1164. {****************************************************************************}
  1165. { TestGraphPrev                                                              }
  1166. {****************************************************************************}
  1167. procedure TestGraphPrev (Graph : PGraph);
  1168. var
  1169.   Counter : LongInt;
  1170.   Item : Pointer;
  1171. begin
  1172.   if ExitTesting
  1173.     then Exit;
  1174.   StartTest('Prev', 'Traversing the graph using Last and Prev...');
  1175.   Counter := 0;
  1176.   Graph^.ExactMatch := False;
  1177.   Item := Graph^.Last;
  1178.   while Item <> nil do
  1179.   begin
  1180.     Graph^.DoneItem(Item);
  1181.     Inc(Counter);
  1182.     Item := Graph^.Prev(Item);
  1183.   end; { while }
  1184.   StopTest;
  1185.   WriteNumResult('Total nodes visited:', Counter);
  1186.   PauseTest;
  1187. end;
  1188.  
  1189. {****************************************************************************}
  1190. { TestGraphPrevThat                                                          }
  1191. {****************************************************************************}
  1192. procedure TestGraphPrevThat (Graph : PGraph; var Key: String5);
  1193. var
  1194.   Hold, Item : Pointer;
  1195.  
  1196.   function MatchFirst(Item : Pointer) : Boolean; far;
  1197.   begin
  1198.     if (Item <> nil) and (TestReader^.ExtractText(Item)^ < 'DRTG')
  1199.       then MatchFirst := True
  1200.       else MatchFirst := False;
  1201.   end; { MatchFirst }
  1202.  
  1203.   function MatchNext(Item : Pointer) : Boolean; far;
  1204.   begin
  1205.     if (Item <> nil) and (TestReader^.ExtractText(Item)^[3] = 'F')
  1206.      then MatchNext := True
  1207.      else MatchNext := False;
  1208.   end; { MatchNext }
  1209.  
  1210. begin
  1211.   if ExitTesting
  1212.     then Exit;
  1213.   Graph^.ExactMatch := False;
  1214.   Item := Graph^.LastThat(@MatchFirst);
  1215.   StartTest('PrevThat', 'Retrieving first item with ''F'' as the 3rd '+
  1216.     'character before last item with key < ''DRTG''');
  1217.   Hold := Item;
  1218.   Item := Graph^.PrevThat(@MatchNext, Item);
  1219.   StopTest;
  1220.   if Item <> nil
  1221.     then begin
  1222.            TestReader^.ShowItem(Item);
  1223.            Key := TestReader^.ExtractText(Item)^;
  1224.          end { if }
  1225.     else begin
  1226.            WriteResult('Not found');
  1227.            Item := Graph^.Last;
  1228.            Key := TestReader^.ExtractText(Item)^;
  1229.            Graph^.DoneItem(Item);
  1230.          end; { else }
  1231.   Graph^.DoneItem(Hold);
  1232.   Graph^.DoneItem(Item);
  1233.   PauseTest;
  1234. end;
  1235.  
  1236. {****************************************************************************}
  1237. { TestHugeArrayStackBottom                                                   }
  1238. {****************************************************************************}
  1239. procedure TestHugeArrayStackBottom (Stack : PHugeArrayStack);
  1240. var
  1241.   Item : Pointer;
  1242. begin
  1243.   if ExitTesting
  1244.     then Exit;
  1245.   StartTest('Bottom', 'Getting item at the bottom of the stack...');
  1246.   Item := Stack^.Bottom;
  1247.   StopTest;
  1248.   TestReader^.ShowItem(Item);
  1249.   PauseTest;
  1250. end;
  1251.  
  1252. {****************************************************************************}
  1253. { TestHugeArrayStackPop                                                      }
  1254. {****************************************************************************}
  1255. procedure TestHugeArrayStackPop (Stack : PHugeArrayStack);
  1256. var
  1257.   Item : Pointer;
  1258.   i : Integer;
  1259. begin
  1260.   if ExitTesting
  1261.     then Exit;
  1262.   StartTest('Pop', 'Getting all items out of the stack...');
  1263.   Writeln(TestWindow^.T);
  1264.   for i := 1 to Stack^.Count do
  1265.   begin
  1266.     SetInitTime;
  1267.     Item := Stack^.Pop;
  1268.     SetFinalTime;
  1269.     WriteSubHeader('Popping '+TestReader^.ExtractText(Item)^);
  1270.     WriteTime;
  1271.     Stack^.FreeItem(Item);
  1272.   end; { for }
  1273.   PauseTest;
  1274. end;
  1275.  
  1276. {****************************************************************************}
  1277. { TestHugeArrayStackPush                                                     }
  1278. {****************************************************************************}
  1279. procedure TestHugeArrayStackPush (Stack : PHugeArrayStack);
  1280. var
  1281.   i : Integer;
  1282.   Item : Pointer;
  1283.   Key : String5;
  1284.   F : Text;
  1285. begin
  1286.   if ExitTesting
  1287.     then Exit;
  1288.   StartTest('Push', 'Adding 20 items to the stack...');
  1289.   Writeln(TestWindow^.T);
  1290.   Assign(F, 'Items.Dat');
  1291.   Reset(F);
  1292.   for i := 1 to 20 do
  1293.   begin
  1294.     Readln(F, Key);
  1295.     if LowMemory
  1296.       then begin
  1297.              Writeln(TestWindow^.T);
  1298.              Writeln(TestWindow^.T);
  1299.              Writeln(TestWindow^.T, 'Not enough memory... aborting test.');
  1300.              ExitTesting := True;
  1301.              Close(F);
  1302.              ResetApplication;
  1303.              Exit;
  1304.            end { if }
  1305.       else begin
  1306.              CreateNonDynamicTestRec(Key+' ', 0, NonDynamicRec);
  1307.              Item := @NonDynamicRec;
  1308.            end; { else }
  1309.     SetInitTime;
  1310.     Stack^.Push(Item);
  1311.     SetFinalTime;
  1312.     WriteSubHeader('Pushing '+Key);
  1313.     WriteTime;
  1314.   end; { for }
  1315.   PauseTest;
  1316. end;
  1317.  
  1318. {****************************************************************************}
  1319. { TestHugeArrayStackTop                                                      }
  1320. {****************************************************************************}
  1321. procedure TestHugeArrayStackTop (Stack : PHugeArrayStack);
  1322. var
  1323.   Item : Pointer;
  1324. begin
  1325.   if ExitTesting
  1326.     then Exit;
  1327.   StartTest('Top', 'Getting item at the top of the stack...');
  1328.   Item := Stack^.Top;
  1329.   StopTest;
  1330.   TestReader^.ShowItem(Item);
  1331.   PauseTest;
  1332. end;
  1333.  
  1334. {****************************************************************************}
  1335. { TestHugeCollectionStackBottom                                              }
  1336. {****************************************************************************}
  1337. procedure TestHugeCollectionStackBottom (Stack : PHugeCollectionStack);
  1338. var
  1339.   Item : Pointer;
  1340. begin
  1341.   if ExitTesting
  1342.     then Exit;
  1343.   StartTest('Bottom', 'Getting item at the bottom of the stack...');
  1344.   Item := Stack^.Bottom;
  1345.   StopTest;
  1346.   TestReader^.ShowItem(Item);
  1347.   PauseTest;
  1348. end;
  1349.  
  1350. {****************************************************************************}
  1351. { TestHugeCollectionStackPop                                                 }
  1352. {****************************************************************************}
  1353. procedure TestHugeCollectionStackPop (Stack : PHugeCollectionStack);
  1354. var
  1355.   Item : Pointer;
  1356.   i : Integer;
  1357. begin
  1358.   if ExitTesting
  1359.     then Exit;
  1360.   StartTest('Pop', 'Getting all items out of the stack...');
  1361.   Writeln(TestWindow^.T);
  1362.   for i := 1 to Stack^.Count do
  1363.   begin
  1364.     SetInitTime;
  1365.     Item := Stack^.Pop;
  1366.     SetFinalTime;
  1367.     WriteSubHeader('Popping '+TestReader^.ExtractText(Item)^);
  1368.     WriteTime;
  1369.     Stack^.FreeItem(Item);
  1370.   end; { for }
  1371.   PauseTest;
  1372. end;
  1373.  
  1374. {****************************************************************************}
  1375. { TestHugeCollectionStackPush                                                }
  1376. {****************************************************************************}
  1377. procedure TestHugeCollectionStackPush (Stack : PHugeCollectionStack);
  1378. var
  1379.   i : Integer;
  1380.   Item : Pointer;
  1381.   Key : String5;
  1382.   F : Text;
  1383. begin
  1384.   if ExitTesting
  1385.     then Exit;
  1386.   StartTest('Push', 'Adding 20 items to the stack...');
  1387.   Writeln(TestWindow^.T);
  1388.   Assign(F, 'Items.Dat');
  1389.   Reset(F);
  1390.   for i := 1 to 20 do
  1391.   begin
  1392.     Readln(F, Key);
  1393.     if LowMemory
  1394.       then begin
  1395.              Writeln(TestWindow^.T);
  1396.              Writeln(TestWindow^.T);
  1397.              Writeln(TestWindow^.T, 'Not enough memory... aborting test.');
  1398.              ExitTesting := True;
  1399.              Close(F);
  1400.              ResetApplication;
  1401.              Exit;
  1402.            end { if }
  1403.       else Item := CreateItem(Key, 0);
  1404.     SetInitTime;
  1405.     Stack^.Push(Item);
  1406.     SetFinalTime;
  1407.     WriteSubHeader('Pushing '+Key);
  1408.     WriteTime;
  1409.   end; { for }
  1410.   PauseTest;
  1411. end;
  1412.  
  1413. {****************************************************************************}
  1414. { TestHugeCollectionStackTop                                                 }
  1415. {****************************************************************************}
  1416. procedure TestHugeCollectionStackTop (Stack : PHugeCollectionStack);
  1417. var
  1418.   Item : Pointer;
  1419. begin
  1420.   if ExitTesting
  1421.     then Exit;
  1422.   StartTest('Top', 'Getting item at the top of the stack...');
  1423.   Item := Stack^.Top;
  1424.   StopTest;
  1425.   TestReader^.ShowItem(Item);
  1426.   PauseTest;
  1427. end;
  1428.  
  1429. {****************************************************************************}
  1430. { TestLinkedStackBottom                                                      }
  1431. {****************************************************************************}
  1432. procedure TestLinkedStackBottom (Stack : PLinkedStack);
  1433. var
  1434.   Item : Pointer;
  1435. begin
  1436.   if ExitTesting
  1437.     then Exit;
  1438.   StartTest('Bottom', 'Getting item at the bottom of the stack...');
  1439.   Item := Stack^.Bottom;
  1440.   StopTest;
  1441.   TestReader^.ShowItem(Item);
  1442.   PauseTest;
  1443. end;
  1444.  
  1445. {****************************************************************************}
  1446. { TestLinkedStackPop                                                         }
  1447. {****************************************************************************}
  1448. procedure TestLinkedStackPop (Stack : PLinkedStack);
  1449. var
  1450.   Item : Pointer;
  1451.   i : Integer;
  1452. begin
  1453.   if ExitTesting
  1454.     then Exit;
  1455.   StartTest('Pop', 'Getting all items out of the stack...');
  1456.   Writeln(TestWindow^.T);
  1457.   for i := 1 to Stack^.Count do
  1458.   begin
  1459.     SetInitTime;
  1460.     Item := Stack^.Pop;
  1461.     SetFinalTime;
  1462.     WriteSubHeader('Popping '+TestReader^.ExtractText(Item)^);
  1463.     WriteTime;
  1464.     Stack^.FreeItem(Item);
  1465.   end; { for }
  1466.   PauseTest;
  1467. end;
  1468.  
  1469. {****************************************************************************}
  1470. { TestLinkedStackPush                                                        }
  1471. {****************************************************************************}
  1472. procedure TestLinkedStackPush (Stack : PLinkedStack);
  1473. var
  1474.   i : Integer;
  1475.   Item : Pointer;
  1476.   Key : String5;
  1477.   F : Text;
  1478. begin
  1479.   if ExitTesting
  1480.     then Exit;
  1481.   StartTest('Push', 'Adding 20 items to the stack...');
  1482.   Writeln(TestWindow^.T);
  1483.   Assign(F, 'Items.Dat');
  1484.   Reset(F);
  1485.   for i := 1 to 20 do
  1486.   begin
  1487.     Readln(F, Key);
  1488.     if LowMemory
  1489.       then begin
  1490.              Writeln(TestWindow^.T);
  1491.              Writeln(TestWindow^.T);
  1492.              Writeln(TestWindow^.T, 'Not enough memory... aborting test.');
  1493.              ExitTesting := True;
  1494.              Close(F);
  1495.              ResetApplication;
  1496.              Exit;
  1497.            end { if }
  1498.       else Item := CreateItem(Key, 0);
  1499.     SetInitTime;
  1500.     Stack^.Push(Item);
  1501.     SetFinalTime;
  1502.     WriteSubHeader('Pushing '+Key);
  1503.     WriteTime;
  1504.   end; { for }
  1505.   PauseTest;
  1506. end;
  1507.  
  1508. {****************************************************************************}
  1509. { TestLinkedStackTop                                                         }
  1510. {****************************************************************************}
  1511. procedure TestLinkedStackTop (Stack : PLinkedStack);
  1512. var
  1513.   Item : Pointer;
  1514. begin
  1515.   if ExitTesting
  1516.     then Exit;
  1517.   StartTest('Top', 'Getting item at the top of the stack...');
  1518.   Item := Stack^.Top;
  1519.   StopTest;
  1520.   TestReader^.ShowItem(Item);
  1521.   PauseTest;
  1522. end;
  1523.  
  1524. {****************************************************************************}
  1525. { TestQueueEnqueue                                                           }
  1526. {****************************************************************************}
  1527. procedure TestQueueEnqueue (Queue : PQueue);
  1528. var
  1529.   F : Text;
  1530.   i : Integer;
  1531.   Key : String5;
  1532.   Item : Pointer;
  1533. begin
  1534.   if ExitTesting
  1535.     then Exit;
  1536.   StartTest('EnQueue', 'Adding 20 items to the queue...');
  1537.   Writeln(TestWindow^.T);
  1538.   Assign(F, 'items.dat');
  1539.   Reset(F);
  1540.   for i := 1 to 20 do
  1541.   begin
  1542.     Readln(F, Key);
  1543.     if LowMemory
  1544.       then begin
  1545.              Writeln(TestWindow^.T);
  1546.              Writeln(TestWindow^.T);
  1547.              Writeln(TestWindow^.T, 'Not enough memory... aborting test.');
  1548.              ExitTesting := True;
  1549.              Close(F);
  1550.              ResetApplication;
  1551.              Exit;
  1552.            end { if }
  1553.       else Item := CreateItem(Key, 0);
  1554.     SetInitTime;
  1555.     Queue^.Enqueue(Item);
  1556.     SetFinalTime;
  1557.     WriteSubHeader('Enqueueing '+Key);
  1558.     WriteTime;
  1559.   end; { for }
  1560.   PauseTest;
  1561. end;
  1562.  
  1563. {****************************************************************************}
  1564. { TestQueueFront                                                             }
  1565. {****************************************************************************}
  1566. procedure TestQueueFront (Queue : PQueue);
  1567. var
  1568.   Item : Pointer;
  1569. begin
  1570.   if ExitTesting
  1571.     then Exit;
  1572.   StartTest('Front', 'Getting item at the front of the queue...');
  1573.   Item := Queue^.Front;
  1574.   StopTest;
  1575.   TestReader^.ShowItem(Item);
  1576.   PauseTest;
  1577. end;
  1578.  
  1579. {****************************************************************************}
  1580. { TestQueueRear                                                              }
  1581. {****************************************************************************}
  1582. procedure TestQueueRear (Queue : PQueue);
  1583. var
  1584.   Item : Pointer;
  1585. begin
  1586.   if ExitTesting
  1587.     then Exit;
  1588.   StartTest('Rear', 'Getting item at the rear of the queue...');
  1589.   Item := Queue^.Rear;
  1590.   StopTest;
  1591.   TestReader^.ShowItem(Item);
  1592.   PauseTest;
  1593. end;
  1594.  
  1595. {****************************************************************************}
  1596. { TestQueueRemove                                                            }
  1597. {****************************************************************************}
  1598. procedure TestQueueRemove (Queue : PQueue);
  1599. var
  1600.   i : Integer;
  1601.   Item : Pointer;
  1602. begin
  1603.   if ExitTesting
  1604.     then Exit;
  1605.   StartTest('Remove', 'Getting all items out of the queue...');
  1606.   Writeln(TestWindow^.T);
  1607.   for i := 1 to Queue^.Count do
  1608.   begin
  1609.     SetInitTime;
  1610.     Item := Queue^.Remove;
  1611.     SetFinalTime;
  1612.     WriteSubHeader('Removing '+TestReader^.ExtractText(Item)^);
  1613.     WriteTime;
  1614.     Queue^.FreeItem(Item);
  1615.   end; { for }
  1616.   PauseTest;
  1617. end;
  1618.  
  1619. {****************************************************************************}
  1620. { TestSequenceAt                                                             }
  1621. {****************************************************************************}
  1622. procedure TestSequenceAt (Sequence : PSequence);
  1623. var
  1624.   Item : Pointer;
  1625.   i : Integer;
  1626.   Index : LongInt;
  1627.   StrIndex : string;
  1628. begin
  1629.   if ExitTesting
  1630.     then Exit;
  1631.   StartTest('At', 'Displaying items at random using At...');
  1632.   Writeln(TestWindow^.T);
  1633.   Randomize;
  1634.   for i := 1 to 20 do
  1635.   begin
  1636.     Item := nil;
  1637.     repeat
  1638.       Sequence^.DoneItem(Item);
  1639.       Index := Random(Pred(Sequence^.Count));
  1640.       SetInitTime;
  1641.       Item := Sequence^.At(Index);
  1642.       SetFinalTime;
  1643.     until (Item <> nil) and (TestReader^.ExtractText(Item) <> nil);
  1644.     Str(Index, StrIndex);
  1645.     WriteSubHeader('Retrieving '+TestReader^.ExtractText(Item)^+' at index '+
  1646.       StrIndex);
  1647.     Sequence^.DoneItem(Item);
  1648.     WriteTime;
  1649.   end; { for }
  1650.   PauseTest;
  1651. end;
  1652.  
  1653. {****************************************************************************}
  1654. { TestSequenceAtDelete                                                       }
  1655. {****************************************************************************}
  1656. procedure TestSequenceAtDelete (Sequence : PSequence);
  1657. var
  1658.   Item : Pointer;
  1659.   i : Integer;
  1660.   Index : LongInt;
  1661.   StrIndex : string;
  1662. begin
  1663.   if ExitTesting
  1664.     then Exit;
  1665.   StartTest('AtDelete', 'Deleting items at random...');
  1666.   Writeln(TestWindow^.T);
  1667.   Randomize;
  1668.   for i := 1 to 20 do
  1669.   begin
  1670.     Item := nil;
  1671.     repeat
  1672.       Sequence^.DoneItem(Item);
  1673.       Index := Random(Pred(Sequence^.Count));
  1674.       Item := Sequence^.At(Index);
  1675.     until (Item <> nil) and (TestReader^.ExtractText(Item) <> nil);
  1676.     Str(Index, StrIndex);
  1677.     WriteSubHeader('Deleting '+TestReader^.ExtractText(Item)^+' at index '+
  1678.       StrIndex);
  1679.     if TestingMemArray
  1680.       then Sequence^.FreeItem(Item);
  1681.     SetInitTime;
  1682.     Sequence^.AtDelete(Index);
  1683.     SetFinalTime;
  1684.     if not TestingMemArray
  1685.       then Sequence^.FreeItem(Item);
  1686.     WriteTime;
  1687.   end; { for }
  1688.   NotifyDataChange;
  1689.   PauseTest;
  1690. end;
  1691.  
  1692. {****************************************************************************}
  1693. { TestSequenceAtFree                                                         }
  1694. {****************************************************************************}
  1695. procedure TestSequenceAtFree (Sequence : PSequence);
  1696. var
  1697.   Item : Pointer;
  1698.   i : Integer;
  1699.   Index : LongInt;
  1700.   StrIndex : string;
  1701. begin
  1702.   if ExitTesting
  1703.     then Exit;
  1704.   StartTest('AtFree', 'Freeing items at random...');
  1705.   Writeln(TestWindow^.T);
  1706.   Randomize;
  1707.   for i := 1 to 20 do
  1708.   begin
  1709.     Item := nil;
  1710.     repeat
  1711.       Sequence^.DoneItem(Item);
  1712.       Index := Random(Pred(Sequence^.Count));
  1713.       Item := Sequence^.At(Index);
  1714.     until (Item <> nil) and (TestReader^.ExtractText(Item) <> nil);
  1715.     Str(Index, StrIndex);
  1716.     WriteSubHeader('Freeing '+TestReader^.ExtractText(Item)^+' at index '+
  1717.       StrIndex);
  1718.     Sequence^.DoneItem(Item);
  1719.     SetInitTime;
  1720.     Sequence^.AtFree(Index);
  1721.     SetFinalTime;
  1722.     WriteTime;
  1723.   end; { for }
  1724.   NotifyDataChange;
  1725.   PauseTest;
  1726. end;
  1727.  
  1728. {****************************************************************************}
  1729. { TestSequenceAtInsert                                                       }
  1730. {****************************************************************************}
  1731. procedure TestSequenceAtInsert (Sequence : PSequence);
  1732. var
  1733.   Item : Pointer;
  1734.   i : Integer;
  1735.   Key : String5;
  1736.   Index : LongInt;
  1737.   StrIndex : string;
  1738.   F : Text;
  1739. begin
  1740.   if ExitTesting
  1741.     then Exit;
  1742.   StartTest('AtInsert', 'Inserting items at random...');
  1743.   Writeln(TestWindow^.T);
  1744.   Assign(F, 'items.dat');
  1745.   Reset(F);
  1746.   Randomize;
  1747.   for i := 1 to 20 do
  1748.   begin
  1749.     Readln(F, Key);
  1750.     if UseNonDynamicTestRec
  1751.       then begin
  1752.              CreateNonDynamicTestRec(Key, 0, NonDynamicRec);
  1753.              Item := @NonDynamicRec;
  1754.            end { if }
  1755.       else if UseNonDynamicTestObject
  1756.              then begin
  1757.                     CreateNonDynamicTestObject(Key+' ', 0, NonDynamicObject);
  1758.                     Item := @NonDynamicObject;
  1759.                   end { if }
  1760.       else if UseNonDynamicTestStaticObject
  1761.              then begin
  1762.                     CreateNonDynamicTestStaticObject(Key+' ', 0,
  1763.                       NonDynamicStaticObject);
  1764.                     Item := @NonDynamicStaticObject;
  1765.                   end { if }
  1766.       else Item := CreateItem(Key, 0);
  1767.     Index := Random(Pred(Sequence^.Count));
  1768.     Str(Index, StrIndex);
  1769.     WriteSubHeader('Inserting '+Key+' at index '+StrIndex);
  1770.     SetInitTime;
  1771.     Sequence^.AtInsert(Index, Item);
  1772.     SetFinalTime;
  1773.     WriteTime;
  1774.   end; { for }
  1775.   Close(F);
  1776.   NotifyDataChange;
  1777.   PauseTest;
  1778. end;
  1779.  
  1780. {****************************************************************************}
  1781. { TestSequenceAtPut                                                          }
  1782. {****************************************************************************}
  1783. procedure TestSequenceAtPut (Sequence : PSequence);
  1784. var
  1785.   New, Item : Pointer;
  1786.   i : Integer;
  1787.   Key : String5;
  1788.   Index : LongInt;
  1789.   StrIndex : string;
  1790.   F : Text;
  1791. begin
  1792.   if ExitTesting
  1793.     then Exit;
  1794.   StartTest('AtPut', 'Replacing items at random...');
  1795.   Writeln(TestWindow^.T);
  1796.   Assign(F, 'items.dat');
  1797.   Reset(F);
  1798.   Randomize;
  1799.   for i := 1 to 20 do
  1800.   begin
  1801.     Readln(F, Key);
  1802.     if UseNonDynamicTestRec
  1803.       then begin
  1804.              CreateNonDynamicTestRec(Key, 0, NonDynamicRec);
  1805.              New := @NonDynamicRec;
  1806.            end { if }
  1807.       else if UseNonDynamicTestObject
  1808.              then begin
  1809.                     CreateNonDynamicTestObject(Key+' ', 0, NonDynamicObject);
  1810.                     New := @NonDynamicObject;
  1811.                   end { if }
  1812.       else if UseNonDynamicTestStaticObject
  1813.              then begin
  1814.                     CreateNonDynamicTestStaticObject(Key+' ', 0,
  1815.                       NonDynamicStaticObject);
  1816.                     Item := @NonDynamicStaticObject;
  1817.                   end { if }
  1818.       else New := CreateItem(Key, 0);
  1819.     Item := nil;
  1820.     repeat
  1821.       Sequence^.DoneItem(Item);
  1822.       Index := Random(Pred(Sequence^.Count));
  1823.       Item := Sequence^.At(Index)
  1824.     until (Item <> nil) and (TestReader^.ExtractText(Item) <> nil);
  1825.     Str(Index, StrIndex);
  1826.     WriteSubHeader('Replacing '+TestReader^.ExtractText(Item)^+' at index '
  1827.       +StrIndex+' with '+Key);
  1828.     if TestingMemArray
  1829.       then Sequence^.FreeItem(Item);
  1830.     SetInitTime;
  1831.     Sequence^.AtPut(Index, New);
  1832.     SetFinalTime;
  1833.     if not TestingMemArray
  1834.       then Sequence^.FreeItem(Item);
  1835.     WriteTime;
  1836.   end; { for }
  1837.   Close(F);
  1838.   NotifyDataChange;
  1839.   PauseTest;
  1840. end;
  1841.  
  1842. {****************************************************************************}
  1843. { TestSequenceDelete                                                         }
  1844. {****************************************************************************}
  1845. procedure TestSequenceDelete (Sequence: PSequence);
  1846. var
  1847.   Count : Byte;
  1848.   Index : LongInt;
  1849.   Item : Pointer;
  1850.  
  1851.   function Match(Item : Pointer) : Boolean; far;
  1852.   begin
  1853.     if (Item <> nil) and (TestReader^.ExtractText(Item) <> nil)
  1854.       then if TestReader^.ExtractText(Item)^[3] = 'X'
  1855.              then Match := True
  1856.              else Match := False
  1857.       else Match := False;
  1858.   end; { Match }
  1859.  
  1860. begin
  1861.   if ExitTesting
  1862.     then Exit;
  1863.   WriteHeader('Delete');
  1864.   WriteSubHeader('Deleting first 20 items with ''X'' as the 3rd '+
  1865.    'character...');
  1866.   Writeln(TestWindow^.T);
  1867.   Item := Sequence^.FirstThat(@Match, Index);
  1868.   Count := 1;
  1869.   while (Item <> nil) and (Count <= 20) do
  1870.   begin
  1871.     WriteSubHeader('Deleting '+TestReader^.ExtractText(Item)^);
  1872.     if TestingMemArray
  1873.       then Sequence^.FreeItem(Item);
  1874.     SetInitTime;
  1875.     Sequence^.Delete(Item);
  1876.     SetFinalTime;
  1877.     WriteTime;
  1878.     if not TestingMemArray
  1879.       then Sequence^.FreeItem(Item);
  1880.     Item := Sequence^.NextThat(@Match, Index);
  1881.     Inc(Count);
  1882.   end; { while }
  1883.   Sequence^.DoneItem(Item);
  1884.   WriteNumResult('Total items deleted:', Pred(Count));
  1885.   NotifyDataChange;
  1886.   PauseTest;
  1887. end;
  1888.  
  1889. {****************************************************************************}
  1890. { TestSequenceDeleteAll                                                      }
  1891. {****************************************************************************}
  1892. procedure TestSequenceDeleteAll (Sequence : PSequence);
  1893. var
  1894.   Items : array [1..TotalDeleteItems] of Pointer;
  1895.   i : Integer;
  1896.   SequenceCount : LongInt;
  1897. begin
  1898.   if ExitTesting
  1899.     then Exit;
  1900.   SequenceCount := Sequence^.Count;
  1901.   if SequenceCount > TotalDeleteItems
  1902.     then SequenceCount := TotalDeleteItems;
  1903.   for i := 1 to SequenceCount do
  1904.     Items[i] := Sequence^.At(Pred(i));
  1905.   if TestingMemArray
  1906.     then for i := 1 to SequenceCount do
  1907.            Sequence^.FreeItem(Items[i]);
  1908.   StartTest('DeleteAll', 'Deleting all items in the container...');
  1909.   Sequence^.DeleteAll;
  1910.   StopTest;
  1911.   WriteSubHeader('Disposing of deleted items...');
  1912.   if not TestingMemArray
  1913.     then for i := 1 to SequenceCount do
  1914.            Sequence^.FreeItem(Items[i]);
  1915.   Writeln(TestWindow^.T, '  done.');
  1916.   NotifyDataChange;
  1917.   PauseTest;
  1918. end;
  1919.  
  1920. {****************************************************************************}
  1921. { TestSequenceFree                                                           }
  1922. {****************************************************************************}
  1923. procedure TestSequenceFree (Sequence: PSequence);
  1924. var
  1925.   Count : Byte;
  1926.   Index : LongInt;
  1927.   Item : Pointer;
  1928.  
  1929.   function Match(Item : Pointer) : Boolean; far;
  1930.   begin
  1931.     if (Item <> nil) and (TestReader^.ExtractText(Item) <> nil)
  1932.       then if TestReader^.ExtractText(Item)^[3] = 'W'
  1933.              then Match := True
  1934.              else Match := False
  1935.       else Match := False;
  1936.   end; { Match }
  1937.  
  1938. begin
  1939.   if ExitTesting
  1940.     then Exit;
  1941.   WriteHeader('Free');
  1942.   WriteSubHeader('Freeing first 20 items with ''W'' as the 3rd '+
  1943.     'character...');
  1944.   Writeln(TestWindow^.T);
  1945.   Item := Sequence^.FirstThat(@Match, Index);
  1946.   Count := 1;
  1947.   while (Item <> nil) and (Count <= 20) do
  1948.   begin
  1949.     WriteSubHeader('Freeing '+TestReader^.ExtractText(Item)^);
  1950.     SetInitTime;
  1951.     Sequence^.Free(Item);
  1952.     SetFinalTime;
  1953.     WriteTime;
  1954.     Item := Sequence^.NextThat(@Match, Index);
  1955.     Inc(Count);
  1956.   end; { while }
  1957.   Sequence^.DoneItem(Item);
  1958.   WriteNumResult('Total items freed:', Pred(Count));
  1959.   NotifyDataChange;
  1960.   PauseTest;
  1961. end;
  1962.  
  1963. {****************************************************************************}
  1964. { TestSequenceFirst                                                          }
  1965. {****************************************************************************}
  1966. procedure TestSequenceFirst (Sequence : PSequence);
  1967. var
  1968.   Index : LongInt;
  1969.   Item : Pointer;
  1970. begin
  1971.   if ExitTesting
  1972.     then Exit;
  1973.   StartTest('First', 'Retrieving the first item in the container...');
  1974.   Item := Sequence^.First(Index);
  1975.   StopTest;
  1976.   if Item <> nil
  1977.     then TestReader^.ShowItem(Item)
  1978.     else WriteResult('nil/deleted');
  1979.   Sequence^.DoneItem(Item);
  1980.   PauseTest;
  1981. end;
  1982.  
  1983. {****************************************************************************}
  1984. { TestSequenceFirstThat                                                      }
  1985. {****************************************************************************}
  1986. procedure TestSequenceFirstThat (Sequence : PSequence);
  1987. var
  1988.   Item : Pointer;
  1989.   Index : LongInt;
  1990.  
  1991.   function Match(Item : Pointer) : Boolean; far;
  1992.   begin
  1993.     if (Item <> nil) and (TestReader^.ExtractText(Item) <> nil)
  1994.       then if TestReader^.ExtractText(Item)^ > 'UXVT'
  1995.              then Match := True
  1996.              else Match := False
  1997.       else Match := False;
  1998.   end; { Match }
  1999.  
  2000. begin
  2001.   if ExitTesting
  2002.     then Exit;
  2003.   StartTest('FirstThat', 'Retrieving first item with key > ''UXVT''');
  2004.   Item := Sequence^.FirstThat(@Match, Index);
  2005.   StopTest;
  2006.   if Item <> nil
  2007.     then TestReader^.ShowItem(Item)
  2008.     else WriteResult('Not found');
  2009.   Sequence^.DoneItem(Item);
  2010.   PauseTest;
  2011. end;
  2012.  
  2013. {****************************************************************************}
  2014. { TestSequenceLast                                                           }
  2015. {****************************************************************************}
  2016. procedure TestSequenceLast (Sequence : PSequence);
  2017. var
  2018.   Index : LongInt;
  2019.   Item : Pointer;
  2020. begin
  2021.   if ExitTesting
  2022.     then Exit;
  2023.   StartTest('Last', 'Retrieving the last item in the container...');
  2024.   Item := Sequence^.Last(Index);
  2025.   StopTest;
  2026.   if Item <> nil
  2027.     then TestReader^.ShowItem(Item)
  2028.     else WriteResult('nil/deleted');
  2029.   Sequence^.DoneItem(Item);
  2030.   PauseTest;
  2031. end;
  2032.  
  2033. {****************************************************************************}
  2034. { TestSequenceLastThat                                                       }
  2035. {****************************************************************************}
  2036. procedure TestSequenceLastThat (Sequence : PSequence);
  2037. var
  2038.   Item : Pointer;
  2039.   Index : LongInt;
  2040.  
  2041.   function Match(Item : Pointer) : Boolean; far;
  2042.   begin
  2043.     if (Item <> nil) and (TestReader^.ExtractText(Item) <> nil)
  2044.       then if TestReader^.ExtractText(Item)^ < 'DRTG'
  2045.              then Match := True
  2046.              else Match := False
  2047.       else Match := False;
  2048.   end; { Match }
  2049.  
  2050. begin
  2051.   if ExitTesting
  2052.     then Exit;
  2053.   StartTest('LastThat', 'Retrieving last item with key < ''DRTG''');
  2054.   Item := Sequence^.LastThat(@Match, Index);
  2055.   StopTest;
  2056.   if Item <> nil
  2057.     then TestReader^.ShowItem(Item)
  2058.     else WriteResult('Not found');
  2059.   Sequence^.DoneItem(Item);
  2060.   PauseTest;
  2061. end;
  2062.  
  2063. {****************************************************************************}
  2064. { TestSequenceNext                                                           }
  2065. {****************************************************************************}
  2066. procedure TestSequenceNext (Sequence : PSequence);
  2067. var
  2068.   Index, Counter : LongInt;
  2069.   Item : Pointer;
  2070. begin
  2071.   if ExitTesting
  2072.     then Exit;
  2073.   StartTest('Next', 'Traversing the container using First and Next '+
  2074.     'methods...');
  2075.   if Sequence^.Status > ctOk
  2076.    then Sequence^.Status := ctOk;
  2077.   Counter := 0;
  2078.   Item := Sequence^.First(Index);
  2079.   while Sequence^.Status = ctOk do
  2080.   begin
  2081.     Sequence^.DoneItem(Item);
  2082.     Inc(Counter);
  2083.     Item := Sequence^.Next(Index);
  2084.   end; { while }
  2085.   StopTest;
  2086.   WriteNumResult('Total nodes visited:', Counter);
  2087.   PauseTest;
  2088. end;
  2089.  
  2090. {****************************************************************************}
  2091. { TestSequenceNextThat                                                       }
  2092. {****************************************************************************}
  2093. procedure TestSequenceNextThat (Sequence : PSequence);
  2094. var
  2095.   Item : Pointer;
  2096.   Index : LongInt;
  2097.  
  2098.   function MatchFirst(Item : Pointer) : Boolean; far;
  2099.   begin
  2100.     if (Item <> nil) and (TestReader^.ExtractText(Item) <> nil)
  2101.       then if TestReader^.ExtractText(Item)^ > 'UXVT'
  2102.              then MatchFirst := True
  2103.              else MatchFirst := False
  2104.       else MatchFirst := False;
  2105.   end; { MatchFirst }
  2106.  
  2107.   function MatchNext(Item : Pointer) : Boolean; far;
  2108.   begin
  2109.     if (Item <> nil) and (TestReader^.ExtractText(Item) <> nil)
  2110.      then if TestReader^.ExtractText(Item)^[3] = 'Q'
  2111.             then MatchNext := True
  2112.             else MatchNext := False
  2113.      else MatchNext := False;
  2114.   end; { MatchNext }
  2115.  
  2116. begin
  2117.   if ExitTesting
  2118.     then Exit;
  2119.   Item := Sequence^.FirstThat(@MatchFirst, Index);
  2120.   Sequence^.DoneItem(Item);
  2121.   StartTest('NextThat', 'Retrieving next item with ''Q'' as the 3rd '+
  2122.     'character after first item with key > ''UXVT''');
  2123.   Item := Sequence^.NextThat(@MatchNext, Index);
  2124.   StopTest;
  2125.   if Item <> nil
  2126.     then TestReader^.ShowItem(Item)
  2127.     else WriteResult('Not found');
  2128.   Sequence^.DoneItem(Item);
  2129.   PauseTest;
  2130. end;
  2131.  
  2132. {****************************************************************************}
  2133. { TestSequencePrev                                                           }
  2134. {****************************************************************************}
  2135. procedure TestSequencePrev (Sequence : PSequence);
  2136. var
  2137.   Index, Counter : LongInt;
  2138.   Item : Pointer;
  2139. begin
  2140.   if ExitTesting
  2141.     then Exit;
  2142.   StartTest('Prev', 'Traversing the container using Last and Prev '+
  2143.     'methods...');
  2144.   if Sequence^.Status > ctOk
  2145.    then Sequence^.Status := ctOk;
  2146.   Counter := 0;
  2147.   Item := Sequence^.Last(Index);
  2148.   while Sequence^.Status = ctOk do
  2149.   begin
  2150.     Sequence^.DoneItem(Item);
  2151.     Inc(Counter);
  2152.     Item := Sequence^.Prev(Index);
  2153.   end; { while }
  2154.   StopTest;
  2155.   WriteNumResult('Total nodes visited:', Counter);
  2156.   PauseTest;
  2157. end;
  2158.  
  2159. {****************************************************************************}
  2160. { TestSequencePrevThat                                                       }
  2161. {****************************************************************************}
  2162. procedure TestSequencePrevThat (Sequence : PSequence);
  2163. var
  2164.   Item : Pointer;
  2165.   Index : LongInt;
  2166.  
  2167.   function MatchFirst(Item : Pointer) : Boolean; far;
  2168.   begin
  2169.     if (Item <> nil) and (TestReader^.ExtractText(Item) <> nil)
  2170.       then if TestReader^.ExtractText(Item)^ < 'DRTG'
  2171.              then MatchFirst := True
  2172.              else MatchFirst := False
  2173.       else MatchFirst := False;
  2174.   end; { MatchFirst }
  2175.  
  2176.   function MatchNext(Item : Pointer) : Boolean; far;
  2177.   begin
  2178.     if (Item <> nil) and (TestReader^.ExtractText(Item) <> nil)
  2179.      then if TestReader^.ExtractText(Item)^[3] = 'F'
  2180.             then MatchNext := True
  2181.             else MatchNext := False
  2182.      else MatchNext := False;
  2183.   end; { MatchNext }
  2184.  
  2185. begin
  2186.   if ExitTesting
  2187.     then Exit;
  2188.   Item := Sequence^.LastThat(@MatchFirst, Index);
  2189.   Sequence^.DoneItem(Item);
  2190.   StartTest('PrevThat', 'Retrieving first item with ''F'' as the 3rd '+
  2191.     'character before last item with key < ''DRTG''');
  2192.   Item := Sequence^.PrevThat(@MatchNext, Index);
  2193.   StopTest;
  2194.   if Item <> nil
  2195.     then TestReader^.ShowItem(Item)
  2196.     else WriteResult('Not found');
  2197.   Sequence^.DoneItem(Item);
  2198.   PauseTest;
  2199. end;
  2200.  
  2201. {****************************************************************************}
  2202. { TestSequenceSearch                                                         }
  2203. {****************************************************************************}
  2204. procedure TestSequenceSearch (Sequence : PSequence);
  2205. var
  2206.   F : Text;
  2207.   i : Integer;
  2208.   Key : String5;
  2209.   Index : LongInt;
  2210. begin
  2211.   if ExitTesting
  2212.     then Exit;
  2213.   Assign(F, 'items.dat');
  2214.   Reset(F);
  2215.   for i := 1 to 20 do
  2216.   begin
  2217.     Readln(F, Key);
  2218.     WriteSubHeader('Searching for '+key);
  2219.     SetInitTime;
  2220.     Sequence^.Search(@Key, Index);
  2221.     Writeln(TestWindow^.T, Index:11);
  2222.   end; { for }
  2223.   Close(F);
  2224.   PauseTest;
  2225. end;
  2226.  
  2227. {****************************************************************************}
  2228. { TestStaticSequenceAtInsert                                                 }
  2229. {****************************************************************************}
  2230. procedure TestStaticSequenceAtInsert (Sequence : PSequence);
  2231. var
  2232.   Item : Pointer;
  2233.   i : Integer;
  2234.   Key : String5;
  2235.   Index : LongInt;
  2236.   StrIndex : string;
  2237.   F : Text;
  2238. begin
  2239.   if ExitTesting
  2240.     then Exit;
  2241.   StartTest('AtInsert', 'Inserting items at random...');
  2242.   Writeln(TestWindow^.T);
  2243.   Assign(F, 'items.dat');
  2244.   Reset(F);
  2245.   Randomize;
  2246.   for i := 1 to 20 do
  2247.   begin
  2248.     Readln(F, Key);
  2249.     if UseNonDynamicTestRec
  2250.       then begin
  2251.              CreateNonDynamicTestRec(Key, 0, NonDynamicRec);
  2252.              Item := @NonDynamicRec;
  2253.            end { if }
  2254.       else if UseNonDynamicTestObject
  2255.              then begin
  2256.                     CreateNonDynamicTestObject(Key+' ', 0, NonDynamicObject);
  2257.                     Item := @NonDynamicObject;
  2258.                   end { if }
  2259.       else if UseNonDynamicTestStaticObject
  2260.              then begin
  2261.                     CreateNonDynamicTestStaticObject(Key+' ', 0,
  2262.                       NonDynamicStaticObject);
  2263.                     Item := @NonDynamicStaticObject;
  2264.                   end { if }
  2265.       else Item := CreateItem(Key, 0);
  2266.     Index := Random(Pred(Sequence^.Count));
  2267.     Str(Index, StrIndex);
  2268.     WriteSubHeader('Inserting '+Key+' at index '+StrIndex);
  2269.     Sequence^.AtFree(Sequence^.LastIndex);
  2270.     SetInitTime;
  2271.     Sequence^.AtInsert(Index, Item);
  2272.     SetFinalTime;
  2273.     WriteTime;
  2274.   end; { for }
  2275.   Close(F);
  2276.   NotifyDataChange;
  2277.   PauseTest;
  2278. end;
  2279.  
  2280. {****************************************************************************}
  2281. { TestStaticSequenceInsert                                                   }
  2282. {****************************************************************************}
  2283. procedure TestStaticSequenceInsert (Sequence: PSequence; TotalItems:
  2284.   LongInt);
  2285. var
  2286.   SubHeader : string;
  2287.   F : Text;
  2288.   i : LongInt;
  2289.   Key : String5;
  2290.   Item : Pointer;
  2291. begin
  2292.   if ExitTesting
  2293.     then Exit;
  2294.   Assign(F, 'items.dat');
  2295.   Reset(F);
  2296.   FormatStr(SubHeader, 'Inserting %d items into the container...',
  2297.     TotalItems);
  2298.   StartTest('AtPut', SubHeader);
  2299.   for i := 0 to Pred(TotalItems) do
  2300.   begin
  2301.     Readln(F, Key);
  2302.     if LowMemory
  2303.       then begin
  2304.              Writeln(TestWindow^.T);
  2305.              Writeln(TestWindow^.T);
  2306.              Writeln(TestWindow^.T, 'Not enough memory... aborting test.');
  2307.              ExitTesting := True;
  2308.              Close(F);
  2309.              ResetApplication;
  2310.              Exit;
  2311.            end { if }
  2312.       else if UseNonDynamicTestRec
  2313.              then begin
  2314.                     CreateNonDynamicTestRec(Key+' ', 0, NonDynamicRec);
  2315.                     Item := @NonDynamicRec;
  2316.                   end { if }
  2317.       else if UseNonDynamicTestObject
  2318.              then begin
  2319.                     CreateNonDynamicTestObject(Key+' ', 0, NonDynamicObject);
  2320.                     Item := @NonDynamicObject;
  2321.                   end { if }
  2322.       else if UseNonDynamicTestStaticObject
  2323.              then begin
  2324.                     CreateNonDynamicTestStaticObject(Key+' ', 0,
  2325.                       NonDynamicStaticObject);
  2326.                     Item := @NonDynamicStaticObject;
  2327.                   end { if }
  2328.       else Item := CreateItem(Key+' ', 0);
  2329.     Sequence^.AtPut(i, Item);
  2330.   end; { for }
  2331.   StopTest;
  2332.   Close(F);
  2333.   NotifyDataChange;
  2334.   PauseTest;
  2335. end;
  2336.  
  2337. {****************************************************************************}
  2338. { TestStreamStackBottom                                                      }
  2339. {****************************************************************************}
  2340. procedure TestStreamStackBottom (Stack : PStreamStack);
  2341. var
  2342.   Item : Pointer;
  2343. begin
  2344.   if ExitTesting
  2345.     then Exit;
  2346.   StartTest('Bottom', 'Getting item at the bottom of the stack...');
  2347.   Item := Stack^.Bottom;
  2348.   StopTest;
  2349.   TestReader^.ShowItem(Item);
  2350.   PauseTest;
  2351. end;
  2352.  
  2353. {****************************************************************************}
  2354. { TestStreamStackPop                                                         }
  2355. {****************************************************************************}
  2356. procedure TestStreamStackPop (Stack : PStreamStack);
  2357. var
  2358.   Item : Pointer;
  2359.   i : Integer;
  2360. begin
  2361.   if ExitTesting
  2362.     then Exit;
  2363.   StartTest('Pop', 'Getting all items out of the stack...');
  2364.   Writeln(TestWindow^.T);
  2365.   for i := 1 to Stack^.Count do
  2366.   begin
  2367.     SetInitTime;
  2368.     Item := Stack^.Pop;
  2369.     SetFinalTime;
  2370.     WriteSubHeader('Popping '+TestReader^.ExtractText(Item)^);
  2371.     WriteTime;
  2372.     Stack^.FreeItem(Item);
  2373.   end; { for }
  2374.   PauseTest;
  2375. end;
  2376.  
  2377. {****************************************************************************}
  2378. { TestStreamStackPush                                                        }
  2379. {****************************************************************************}
  2380. procedure TestStreamStackPush (Stack : PStreamStack);
  2381. var
  2382.   i : Integer;
  2383.   Item : Pointer;
  2384.   Key : String5;
  2385.   F : Text;
  2386. begin
  2387.   if ExitTesting
  2388.     then Exit;
  2389.   StartTest('Push', 'Adding 20 items to the stack...');
  2390.   Writeln(TestWindow^.T);
  2391.   Assign(F, 'Items.Dat');
  2392.   Reset(F);
  2393.   for i := 1 to 20 do
  2394.   begin
  2395.     Readln(F, Key);
  2396.     if LowMemory
  2397.       then begin
  2398.              Writeln(TestWindow^.T);
  2399.              Writeln(TestWindow^.T);
  2400.              Writeln(TestWindow^.T, 'Not enough memory... aborting test.');
  2401.              ExitTesting := True;
  2402.              Close(F);
  2403.              ResetApplication;
  2404.              Exit;
  2405.            end { if }
  2406.       else Item := CreateItem(Key, 0);
  2407.     SetInitTime;
  2408.     Stack^.Push(Item);
  2409.     SetFinalTime;
  2410.     WriteSubHeader('Pushing '+Key);
  2411.     WriteTime;
  2412.   end; { for }
  2413.   PauseTest;
  2414. end;
  2415.  
  2416. {****************************************************************************}
  2417. { TestStreamStackTop                                                         }
  2418. {****************************************************************************}
  2419. procedure TestStreamStackTop (Stack : PStreamStack);
  2420. var
  2421.   Item : Pointer;
  2422. begin
  2423.   if ExitTesting
  2424.     then Exit;
  2425.   StartTest('Top', 'Getting item at the top of the stack...');
  2426.   Item := Stack^.Top;
  2427.   StopTest;
  2428.   TestReader^.ShowItem(Item);
  2429.   PauseTest;
  2430. end;
  2431.  
  2432. {****************************************************************************}
  2433. { TestTreeTraverse                                                           }
  2434. {****************************************************************************}
  2435. procedure TestTreeTraverse(Tree: PBinaryTree);
  2436. var
  2437.   Counter : Integer;
  2438.  
  2439.   procedure DisplayItem(Item : Pointer); far;
  2440.   begin
  2441.     Inc(Counter);
  2442.     if Counter <= 20
  2443.       then if Item <> nil
  2444.              then TestReader^.ShowItem(Item);
  2445.   end; { DisplayItem }
  2446.  
  2447. begin
  2448.   if ExitTesting
  2449.     then Exit;
  2450.   Counter := 0;
  2451.   StartTest('Traverse', 'Traversing items in order...');
  2452.   Writeln(TestWindow^.T);
  2453.   WriteSubHeader('(displaying first 20 items)');
  2454.   Writeln(TestWindow^.T);
  2455.   Tree^.Traverse(@DisplayItem, InOrder);
  2456.   WriteSubHeader('done...');
  2457.   StopTest;
  2458.   PauseTest;
  2459.  
  2460.   if ExitTesting
  2461.     then Exit;
  2462.   Counter := 0;
  2463.   StartTest('Traverse', 'Traversing items in pre-order...');
  2464.   Writeln(TestWindow^.T);
  2465.   WriteSubHeader('(displaying first 20 items)');
  2466.   Writeln(TestWindow^.T);
  2467.   Tree^.Traverse(@DisplayItem, PreOrder);
  2468.   WriteSubHeader('done...');
  2469.   StopTest;
  2470.   PauseTest;
  2471.  
  2472.   if ExitTesting
  2473.     then Exit;
  2474.   Counter := 0;
  2475.   StartTest('Traverse', 'Traversing items in post-order...');
  2476.   Writeln(TestWindow^.T);
  2477.   WriteSubHeader('(displaying first 20 items)');
  2478.   Writeln(TestWindow^.T);
  2479.   Tree^.Traverse(@DisplayItem, PostOrder);
  2480.   WriteSubHeader('done...');
  2481.   StopTest;
  2482.   PauseTest;
  2483. end;
  2484.  
  2485. {****************************************************************************}
  2486. { TestTreeTraverseThat                                                       }
  2487. {****************************************************************************}
  2488. procedure TestTreeTraverseThat(Tree: PBinaryTree);
  2489. var
  2490.   Counter : Integer;
  2491.  
  2492.   procedure DisplayItem(Item : Pointer); far;
  2493.   begin
  2494.     Inc(Counter);
  2495.     if Counter <= 20
  2496.       then if Item <> nil
  2497.              then TestReader^.ShowItem(Item);
  2498.   end; { DisplayItem }
  2499.  
  2500.   function Match(Item : Pointer): Boolean; far;
  2501.   begin
  2502.     if (Item <> nil) and (TestReader^.ExtractText(Item)^[3] = 'Q')
  2503.       then Match := True
  2504.       else Match := False;
  2505.   end; { Match }
  2506.  
  2507. begin
  2508.   if ExitTesting
  2509.     then Exit;
  2510.   Counter := 0;
  2511.   StartTest('TraverseThat', 'Displaying in-order items with 3rd char=Q...');
  2512.   Writeln(TestWindow^.T);
  2513.   WriteSubHeader('(displaying first 20 items)');
  2514.   Writeln(TestWindow^.T);
  2515.   Tree^.TraverseThat(@Match, @DisplayItem, InOrder);
  2516.   WriteSubHeader('done...');
  2517.   StopTest;
  2518.   PauseTest;
  2519.  
  2520.   if ExitTesting
  2521.     then Exit;
  2522.   Counter := 0;
  2523.   StartTest('TraverseThat', 'Displaying in pre-order items with 3rd char=Q...');
  2524.   Writeln(TestWindow^.T);
  2525.   WriteSubHeader('(displaying first 20 items)');
  2526.   Writeln(TestWindow^.T);
  2527.   Tree^.TraverseThat(@Match, @DisplayItem, PreOrder);
  2528.   WriteSubHeader('done...');
  2529.   StopTest;
  2530.   PauseTest;
  2531.  
  2532.   if ExitTesting
  2533.     then Exit;
  2534.   Counter := 0;
  2535.   StartTest('TraverseThat', 'Displaying in post-order items with 3rd char=Q...');
  2536.   Writeln(TestWindow^.T);
  2537.   WriteSubHeader('(displaying first 20 items)');
  2538.   Writeln(TestWindow^.T);
  2539.   Tree^.TraverseThat(@Match, @DisplayItem, PostOrder);
  2540.   WriteSubHeader('done...');
  2541.   StopTest;
  2542.   PauseTest;
  2543. end;
  2544.  
  2545. begin
  2546.   LowMemSize := 5120 div 16;
  2547. end.